Make filter constructors return exact types

Make functions like gtk_custom_filter_new() return
the actual type they construct.

Update all callers.

diff --git a/demos/constraint-editor/constraint-view.c b/demos/constraint-editor/constraint-view.c
index 5c66bf9d419636226c40fe5e139a0485d6ec19ef..cc5b11c0f50b4690649c7833183df9c08d688070 100644 (file)
--- a/demos/constraint-editor/constraint-view.c
+++ b/demos/constraint-editor/constraint-view.c
@@ -177,11 +177,11 @@ constraint_view_init (ConstraintView *self)
   guides = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (manager));
 
   all_constraints = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (manager));
-  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
   constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, filter);
 
   all_children = gtk_widget_observe_children (GTK_WIDGET (self));
-  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
   children = (GListModel *)gtk_filter_list_model_new (all_children, filter);
 
   list = g_list_store_new (G_TYPE_LIST_MODEL);

diff --git a/demos/gtk-demo/listview_settings.c b/demos/gtk-demo/listview_settings.c
index 2631f346e2aaa8efc97a9c2c30c46334e9244b1c..57aa7d576f360638ca9fb327a2bae77af23a0904 100644 (file)
--- a/demos/gtk-demo/listview_settings.c
+++ b/demos/gtk-demo/listview_settings.c
@@ -247,7 +247,7 @@ transform_settings_to_keys (GBinding     *binding,
   sort_model = gtk_sort_list_model_new (G_LIST_MODEL (store),
                                         g_object_ref (gtk_column_view_get_sorter (GTK_COLUMN_VIEW (data))));
 
-  filter = gtk_string_filter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name"));
+  filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name")));
   g_set_object (&current_filter, filter);
   filter_model = gtk_filter_list_model_new (G_LIST_MODEL (sort_model), filter);
 

diff --git a/demos/gtk-demo/listview_words.c b/demos/gtk-demo/listview_words.c
index 4932d3f9d729bdeba11440d8b42796517bb17b9b..4aa9a9977ce793a7c8c15a8c0acf8b84bb2055b6 100644 (file)
--- a/demos/gtk-demo/listview_words.c
+++ b/demos/gtk-demo/listview_words.c
@@ -179,7 +179,7 @@ do_listview_words (GtkWidget *do_widget)
         }
       g_object_unref (file);
 
-      filter = gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string"));
+      filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string")));
       filter_model = gtk_filter_list_model_new (G_LIST_MODEL (stringlist), filter);
       gtk_filter_list_model_set_incremental (filter_model, TRUE);
 

diff --git a/demos/gtk-demo/main.c b/demos/gtk-demo/main.c
index c1b97bbade272762eef8d6dd085c79d2ed018e9c..9abbd0f94374e76cc2970b5bda4a6e338ef49867 100644 (file)
--- a/demos/gtk-demo/main.c
+++ b/demos/gtk-demo/main.c
@@ -695,9 +695,11 @@ filter_demo (GtkDemo *demo)
 }
 
 static gboolean
-demo_filter_by_name (GtkTreeListRow     *row,
-                     GtkFilterListModel *model)
+demo_filter_by_name (gpointer item,
+                     gpointer user_data)
 {
+  GtkTreeListRow *row = item;
+  GtkFilterListModel *model = user_data;
   GListModel *children;
   GtkDemo *demo;
   guint i, n;
@@ -865,9 +867,10 @@ activate (GApplication *app)
                                        NULL,
                                        NULL);
   filter_model = gtk_filter_list_model_new (G_LIST_MODEL (treemodel), NULL);
-  filter = gtk_custom_filter_new ((GtkCustomFilterFunc)demo_filter_by_name, filter_model, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (demo_filter_by_name, filter_model, NULL));
   gtk_filter_list_model_set_filter (filter_model, filter);
   g_object_unref (filter);
+
   search_entry = GTK_WIDGET (gtk_builder_get_object (builder, "search-entry"));
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (demo_search_changed_cb), filter);
 

diff --git a/demos/icon-browser/iconbrowserwin.c b/demos/icon-browser/iconbrowserwin.c
index c0302e681ca68e65bdd65a1a175fb76a9d57050a..876c09a0d1a2ad36fa88f37c32fc675d5d4169d9 100644 (file)
--- a/demos/icon-browser/iconbrowserwin.c
+++ b/demos/icon-browser/iconbrowserwin.c
@@ -357,7 +357,7 @@ icon_browser_window_init (IconBrowserWindow *win)
 
   filter = gtk_filter_list_model_get_filter (GTK_FILTER_LIST_MODEL (win->icon_filter_model));
 
-  win->name_filter = gtk_custom_filter_new (filter_by_icon_name, NULL, NULL);
+  win->name_filter = GTK_FILTER (gtk_custom_filter_new (filter_by_icon_name, NULL, NULL));
 
   gtk_multi_filter_append (GTK_MULTI_FILTER (filter), g_object_ref (win->name_filter));
 }

diff --git a/gtk/gtkboolfilter.c b/gtk/gtkboolfilter.c
index de37ac0bd2d612562ecf0eff8b02b355a047c7af..b44f472fc6392d76c264ffbebac88195322fd69f 100644 (file)
--- a/gtk/gtkboolfilter.c
+++ b/gtk/gtkboolfilter.c
@@ -195,10 +195,10 @@ gtk_bool_filter_init (GtkBoolFilter *self)
  *
  * Returns: a new #GtkBoolFilter
  **/
-GtkFilter *
+GtkBoolFilter *
 gtk_bool_filter_new (GtkExpression *expression)
 {
-  GtkFilter *result;
+  GtkBoolFilter *result;
 
   result = g_object_new (GTK_TYPE_BOOL_FILTER,
                          "expression", expression,

diff --git a/gtk/gtkboolfilter.h b/gtk/gtkboolfilter.h
index 937f74a3e0205b445358b7fb26d0b3b307ad9894..e81345339cf18f5b683a3c58f1037838c66fcbca 100644 (file)
--- a/gtk/gtkboolfilter.h
+++ b/gtk/gtkboolfilter.h
@@ -34,7 +34,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkBoolFilter, gtk_bool_filter, GTK, BOOL_FILTER, GtkFilter)
 
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_bool_filter_new                     (GtkExpression          *expression);
+GtkBoolFilter *         gtk_bool_filter_new                     (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 GtkExpression *         gtk_bool_filter_get_expression          (GtkBoolFilter          *self);

diff --git a/gtk/gtkcustomfilter.c b/gtk/gtkcustomfilter.c
index 13bcf86342158b97cfd6ff951526463f2b6fb920..34f7dfb1cd9d1b57908d7bb43a00952724f10d20 100644 (file)
--- a/gtk/gtkcustomfilter.c
+++ b/gtk/gtkcustomfilter.c
@@ -108,9 +108,9 @@ gtk_custom_filter_init (GtkCustomFilter *self)
  * If the filter func changes its filtering behavior,
  * gtk_filter_changed() needs to be called.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkCustomFilter
  **/
-GtkFilter *
+GtkCustomFilter *
 gtk_custom_filter_new (GtkCustomFilterFunc match_func,
                        gpointer            user_data,
                        GDestroyNotify      user_destroy)
@@ -121,7 +121,7 @@ gtk_custom_filter_new (GtkCustomFilterFunc match_func,
 
   gtk_custom_filter_set_filter_func (result, match_func, user_data, user_destroy);
 
-  return GTK_FILTER (result);
+  return result;
 }
 
 /**

diff --git a/gtk/gtkcustomfilter.h b/gtk/gtkcustomfilter.h
index c6ee0638867cf56f94d6781df82f797bdba55660..784e4fdca94db2af9121202c012752b60839a003 100644 (file)
--- a/gtk/gtkcustomfilter.h
+++ b/gtk/gtkcustomfilter.h
@@ -45,7 +45,7 @@ typedef gboolean (* GtkCustomFilterFunc) (gpointer item, gpointer user_data);
 GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkCustomFilter, gtk_custom_filter, GTK, CUSTOM_FILTER, GtkFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_custom_filter_new                   (GtkCustomFilterFunc     match_func,
+GtkCustomFilter *       gtk_custom_filter_new                   (GtkCustomFilterFunc     match_func,
                                                                  gpointer                user_data,
                                                                  GDestroyNotify          user_destroy);
 

diff --git a/gtk/gtkcustompaperunixdialog.c b/gtk/gtkcustompaperunixdialog.c
index ce282f8c321ee91ed5d2bd83a5490103f3453654..b86d86604d22050050131aac8a80af1be10ab496 100644 (file)
--- a/gtk/gtkcustompaperunixdialog.c
+++ b/gtk/gtkcustompaperunixdialog.c
@@ -323,7 +323,7 @@ gtk_custom_paper_unix_dialog_init (GtkCustomPaperUnixDialog *dialog)
 
   full_list = G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (printer_list_list)));
 
-  filter = gtk_custom_filter_new (match_func, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (match_func, NULL, NULL));
   dialog->printer_list = G_LIST_MODEL (gtk_filter_list_model_new (full_list, filter));
 
   dialog->custom_paper_list = g_list_store_new (GTK_TYPE_PAGE_SETUP);

diff --git a/gtk/gtkdropdown.c b/gtk/gtkdropdown.c
index feebfa188815305f3dc96d63813e02fc5b5e329d..66885905fc0448dfd52ac0f3f26de5f1a1c1692f 100644 (file)
--- a/gtk/gtkdropdown.c
+++ b/gtk/gtkdropdown.c
@@ -203,11 +203,11 @@ update_filter (GtkDropDown *self)
 
       if (self->expression)
         {
-          filter = gtk_string_filter_new (gtk_expression_ref (self->expression));
+          filter = GTK_FILTER (gtk_string_filter_new (gtk_expression_ref (self->expression)));
           gtk_string_filter_set_match_mode (GTK_STRING_FILTER (filter), GTK_STRING_FILTER_MATCH_MODE_PREFIX);
         }
       else
-        filter = gtk_every_filter_new ();
+        filter = GTK_FILTER (gtk_every_filter_new ());
       gtk_filter_list_model_set_filter (GTK_FILTER_LIST_MODEL (self->filter_model), filter);
       g_object_unref (filter);
     }

diff --git a/gtk/gtkmultifilter.c b/gtk/gtkmultifilter.c
index 922b8fb86802f5f743071d07d97145bf9b8cde68..8211295fb2373cf798f74bcfc6713245471790df 100644 (file)
--- a/gtk/gtkmultifilter.c
+++ b/gtk/gtkmultifilter.c
@@ -302,9 +302,9 @@ gtk_any_filter_init (GtkAnyFilter *self)
  * In particular, this means that if no filter has been added to
  * it, the filter matches no item.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkAnyFilter
  **/
-GtkFilter *
+GtkAnyFilter *
 gtk_any_filter_new (void)
 {
   return g_object_new (GTK_TYPE_ANY_FILTER, NULL);
@@ -400,9 +400,9 @@ gtk_every_filter_init (GtkEveryFilter *self)
  * In particular, this means that if no filter has been added to
  * it, the filter matches every item.
  *
- * Returns: a new #GtkFilter
+ * Returns: a new #GtkEveryFilter
  **/
-GtkFilter *
+GtkEveryFilter *
 gtk_every_filter_new (void)
 {
   return g_object_new (GTK_TYPE_EVERY_FILTER, NULL);

diff --git a/gtk/gtkmultifilter.h b/gtk/gtkmultifilter.h
index 492539e0dca19dbe4a6977f32728ad0f8ee86204..77ada4c7ccdc6dad9870a042a6933f40c7e814e1 100644 (file)
--- a/gtk/gtkmultifilter.h
+++ b/gtk/gtkmultifilter.h
@@ -44,13 +44,13 @@ void                    gtk_multi_filter_remove                 (GtkMultiFilter
 GDK_AVAILABLE_IN_ALL
 GDK_DECLARE_INTERNAL_TYPE (GtkAnyFilter, gtk_any_filter, GTK, ANY_FILTER, GtkMultiFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_any_filter_new                      (void);
+GtkAnyFilter *          gtk_any_filter_new                      (void);
 
 #define GTK_TYPE_EVERY_FILTER             (gtk_every_filter_get_type ())
 GDK_AVAILABLE_IN_ALL
 GDK_DECLARE_INTERNAL_TYPE (GtkEveryFilter, gtk_every_filter, GTK, EVERY_FILTER, GtkMultiFilter)
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_every_filter_new                    (void);
+GtkEveryFilter *        gtk_every_filter_new                    (void);
 
 
 G_END_DECLS

diff --git a/gtk/gtkpagesetupunixdialog.c b/gtk/gtkpagesetupunixdialog.c
index 4fe2a031918aba66dd9b69885c09bf22cfc45fec..8cc9768a5a5d58268514bcd4345d165e02b392c5 100644 (file)
--- a/gtk/gtkpagesetupunixdialog.c
+++ b/gtk/gtkpagesetupunixdialog.c
@@ -324,7 +324,7 @@ gtk_page_setup_unix_dialog_init (GtkPageSetupUnixDialog *dialog)
 
   full_list = G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (printer_list_list)));
 
-  filter = gtk_custom_filter_new (match_func, NULL, NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (match_func, NULL, NULL));
   dialog->printer_list = G_LIST_MODEL (gtk_filter_list_model_new (full_list, filter));
 
   factory = gtk_signal_list_item_factory_new ();

diff --git a/gtk/gtkprintunixdialog.c b/gtk/gtkprintunixdialog.c
index e078114b0272f7dc279b8c87f7c9079cad6485ac..f4bdaa0f04953823ffe469c9d7afc76752db6b79 100644 (file)
--- a/gtk/gtkprintunixdialog.c
+++ b/gtk/gtkprintunixdialog.c
@@ -742,7 +742,8 @@ gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
   GListModel *selection;
   GtkSorter *sorter;
   GtkFilter *filter;
-  GtkFilter *filter1;
+  GtkStringFilter *filter1;
+  GtkCustomFilter *filter2;
   GtkListItemFactory *factory;
   GListStore *store;
   GListModel *paper_size_list;
@@ -813,19 +814,19 @@ gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
   sorter = gtk_custom_sorter_new (default_printer_list_sort_func, NULL, NULL);
   sorted = G_LIST_MODEL (gtk_sort_list_model_new (model, sorter));
 
-  filter = gtk_every_filter_new ();
+  filter = GTK_FILTER (gtk_every_filter_new ());
 
   filter1 = gtk_string_filter_new (
                 gtk_cclosure_expression_new (G_TYPE_STRING,
                                              NULL, 0, NULL,
                                              G_CALLBACK (get_printer_key),
                                              NULL, NULL));
-  gtk_string_filter_set_match_mode (GTK_STRING_FILTER (filter1), GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter1), TRUE);
-  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), filter1);
+  gtk_string_filter_set_match_mode (filter1, GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
+  gtk_string_filter_set_ignore_case (filter1, TRUE);
+  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), GTK_FILTER (filter1));
 
-  filter1 = gtk_custom_filter_new (is_printer_active, dialog, NULL);
-  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), filter1);
+  filter2 = gtk_custom_filter_new (is_printer_active, dialog, NULL);
+  gtk_multi_filter_append (GTK_MULTI_FILTER (filter), GTK_FILTER (filter2));
 
   filtered = G_LIST_MODEL (gtk_filter_list_model_new (sorted, filter));
 

diff --git a/gtk/gtkstringfilter.c b/gtk/gtkstringfilter.c
index a3213ad6495b55d9e061ce61b9b562611a12dd4e..326361d9cc7a7af304c0b5c0d8248e7b6a28f01a 100644 (file)
--- a/gtk/gtkstringfilter.c
+++ b/gtk/gtkstringfilter.c
@@ -313,10 +313,10 @@ gtk_string_filter_init (GtkStringFilter *self)
  *
  * Returns: a new #GtkStringFilter
  **/
-GtkFilter *
+GtkStringFilter *
 gtk_string_filter_new (GtkExpression *expression)
 {
-  GtkFilter *result;
+  GtkStringFilter *result;
 
   result = g_object_new (GTK_TYPE_STRING_FILTER,
                          "expression", expression,

diff --git a/gtk/gtkstringfilter.h b/gtk/gtkstringfilter.h
index 6b8a85234b0824cfbeefe976317c15c01ef5d07e..8852829314b611c705c5db30b434394b6d7a27a2 100644 (file)
--- a/gtk/gtkstringfilter.h
+++ b/gtk/gtkstringfilter.h
@@ -51,7 +51,7 @@ GDK_AVAILABLE_IN_ALL
 G_DECLARE_FINAL_TYPE (GtkStringFilter, gtk_string_filter, GTK, STRING_FILTER, GtkFilter)
 
 GDK_AVAILABLE_IN_ALL
-GtkFilter *             gtk_string_filter_new                   (GtkExpression          *expression);
+GtkStringFilter *       gtk_string_filter_new                   (GtkExpression          *expression);
 
 GDK_AVAILABLE_IN_ALL
 const char *            gtk_string_filter_get_search            (GtkStringFilter        *self);

diff --git a/gtk/inspector/a11y.c b/gtk/inspector/a11y.c
index 777e92b78924f2014b365d6c8c81b549c4cf1d56..f4c93b3d65ff8287c816adadf9d3597366726ed5 100644 (file)
--- a/gtk/inspector/a11y.c
+++ b/gtk/inspector/a11y.c
@@ -230,7 +230,7 @@ update_attributes (GtkInspectorA11y *sl)
 {
   GtkATContext *context;
   GListStore *store;
-  GtkFilter *filter;
+  GtkBoolFilter *filter;
   GtkFilterListModel *filter_model;
   GtkNoSelection *selection;
   GObject *obj;
@@ -311,9 +311,9 @@ update_attributes (GtkInspectorA11y *sl)
   g_type_class_unref (eclass);
 
   filter = gtk_bool_filter_new (gtk_property_expression_new (accessible_attribute_get_type (), NULL, "is-default"));
-  gtk_bool_filter_set_invert (GTK_BOOL_FILTER (filter), TRUE);
+  gtk_bool_filter_set_invert (filter, TRUE);
 
-  filter_model = gtk_filter_list_model_new (G_LIST_MODEL (store), filter);
+  filter_model = gtk_filter_list_model_new (G_LIST_MODEL (store), GTK_FILTER (filter));
   selection = gtk_no_selection_new (G_LIST_MODEL (filter_model));
   gtk_column_view_set_model (GTK_COLUMN_VIEW (sl->attributes), GTK_SELECTION_MODEL (selection));
   g_object_unref (selection);

diff --git a/gtk/inspector/object-tree.c b/gtk/inspector/object-tree.c
index 29b3a8780b7665b82482ad1163e66b026f390610..664ad3074264026d10553b26dfc238e4b5fb219c 100644 (file)
--- a/gtk/inspector/object-tree.c
+++ b/gtk/inspector/object-tree.c
@@ -1135,8 +1135,9 @@ toplevel_filter_func (gpointer item,
 static GListModel *
 create_root_model (GdkDisplay *display)
 {
-  GtkFilter *custom_filter;
-  GtkFilterListModel *filter;
+  GtkFilter *filter;
+  GtkFilterListModel *filter_model;
+  GListModel *model;
   GListStore *list, *special;
   gpointer item;
 
@@ -1150,12 +1151,11 @@ create_root_model (GdkDisplay *display)
   g_list_store_append (list, special);
   g_object_unref (special);
 
-  filter = gtk_filter_list_model_new (NULL, NULL);
-  custom_filter = gtk_custom_filter_new (toplevel_filter_func, display, NULL);
-  gtk_filter_list_model_set_filter (filter, custom_filter);
-  gtk_filter_list_model_set_model (filter, gtk_window_get_toplevels ());
-  g_list_store_append (list, filter);
-  g_object_unref (filter);
+  filter = GTK_FILTER (gtk_custom_filter_new (toplevel_filter_func, display, NULL));
+  model = gtk_window_get_toplevels ();
+  filter_model = gtk_filter_list_model_new (g_object_ref (model), filter);
+  g_list_store_append (list, filter_model);
+  g_object_unref (filter_model);
 
   return G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (list)));
 }

diff --git a/gtk/inspector/prop-list.c b/gtk/inspector/prop-list.c
index d4f689408e6480f85466611e3dc54bb3ece06d8b..b74ded47a1bad9e54bb38c86faee57b7f5919ce2 100644 (file)
--- a/gtk/inspector/prop-list.c
+++ b/gtk/inspector/prop-list.c
@@ -59,7 +59,7 @@ struct _GtkInspectorPropListPrivate
   GtkWidget *search_entry;
   GtkWidget *search_stack;
   GtkWidget *list;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkColumnViewColumn *name;
   GtkColumnViewColumn *type;
   GtkColumnViewColumn *origin;
@@ -114,14 +114,14 @@ gtk_inspector_prop_list_init (GtkInspectorPropList *pl)
   pl->priv = gtk_inspector_prop_list_get_instance_private (pl);
   gtk_widget_init_template (GTK_WIDGET (pl));
   pl->priv->filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_match_mode (GTK_STRING_FILTER (pl->priv->filter), GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
+  gtk_string_filter_set_match_mode (pl->priv->filter, GTK_STRING_FILTER_MATCH_MODE_SUBSTRING);
 
   sorter = gtk_string_sorter_new (gtk_cclosure_expression_new (G_TYPE_STRING, NULL,
                                                                0, NULL,
                                                                (GCallback)holder_prop,
                                                                NULL, NULL));
  
-  gtk_string_filter_set_expression (GTK_STRING_FILTER (pl->priv->filter),
+  gtk_string_filter_set_expression (pl->priv->filter,
                                     gtk_string_sorter_get_expression (GTK_STRING_SORTER (sorter)));
 
   gtk_column_view_column_set_sorter (pl->priv->name, sorter);
@@ -217,7 +217,7 @@ update_filter (GtkInspectorPropList *pl,
   const char *text;
 
   text = gtk_editable_get_text (GTK_EDITABLE (entry));
-  gtk_string_filter_set_search (GTK_STRING_FILTER (pl->priv->filter), text);
+  gtk_string_filter_set_search (pl->priv->filter, text);
 }
 
 static void
@@ -622,7 +622,7 @@ gtk_inspector_prop_list_set_object (GtkInspectorPropList *pl,
   if (GTK_IS_WIDGET (object))
     g_signal_connect_object (object, "destroy", G_CALLBACK (cleanup_object), pl, G_CONNECT_SWAPPED);
 
-  filtered = G_LIST_MODEL (gtk_filter_list_model_new (G_LIST_MODEL (store), g_object_ref (pl->priv->filter)));
+  filtered = G_LIST_MODEL (gtk_filter_list_model_new (G_LIST_MODEL (store), g_object_ref (GTK_FILTER (pl->priv->filter))));
   sorted = gtk_sort_list_model_new (filtered, NULL);
   list = G_LIST_MODEL (gtk_no_selection_new (G_LIST_MODEL (sorted)));
 

diff --git a/tests/testcolumnview.c b/tests/testcolumnview.c
index d38e83ce6d080c98bde6c6b1f01592ec67895dda..2c5643cb233eb84012fc84fe37f4ffff65006fdc 100644 (file)
--- a/tests/testcolumnview.c
+++ b/tests/testcolumnview.c
@@ -756,7 +756,7 @@ main (int argc, char *argv[])
   sorter = gtk_tree_list_row_sorter_new (g_object_ref (gtk_column_view_get_sorter (GTK_COLUMN_VIEW (view))));
   sort = gtk_sort_list_model_new (G_LIST_MODEL (tree), sorter);
 
-  custom_filter = gtk_custom_filter_new (match_file, g_object_ref (search_entry), g_object_unref);
+  custom_filter = GTK_FILTER (gtk_custom_filter_new (match_file, g_object_ref (search_entry), g_object_unref));
   filter = gtk_filter_list_model_new (G_LIST_MODEL (sort), custom_filter);
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (search_changed_cb), custom_filter);
 

diff --git a/tests/testlistview.c b/tests/testlistview.c
index 53234078b58909d5a0fc27e25d97f8fe925d7ecf..2eeb89fe54c58e8d53ad229e5930cdd7428a86e1 100644 (file)
--- a/tests/testlistview.c
+++ b/tests/testlistview.c
@@ -629,7 +629,7 @@ main (int argc, char *argv[])
                                   NULL, NULL);
   g_object_unref (root);
 
-  custom_filter = gtk_custom_filter_new (match_file, search_entry, NULL);
+  custom_filter = GTK_FILTER (gtk_custom_filter_new (match_file, search_entry, NULL));
   filter = gtk_filter_list_model_new (G_LIST_MODEL (tree), custom_filter);
   g_signal_connect (search_entry, "search-changed", G_CALLBACK (search_changed_cb), custom_filter);
 

diff --git a/testsuite/gtk/expression.c b/testsuite/gtk/expression.c
index 45c5c1a1f227f018dc8f808f81aa6969eefbe7d9..a874e562a41098110f43afad8a943febff36e5df 100644 (file)
--- a/testsuite/gtk/expression.c
+++ b/testsuite/gtk/expression.c
@@ -38,7 +38,7 @@ test_property (void)
   GtkStringFilter *filter;
   guint counter = 0;
 
-  filter = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter = gtk_string_filter_new (NULL);
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
   watch = gtk_expression_watch (expr, filter, inc_counter, &counter, NULL);
 
@@ -192,7 +192,7 @@ test_nested (void)
   GtkExpression *list_expr;
   GtkExpression *filter_expr;
   GtkExpression *expr;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListModel *list;
   GtkFilterListModel *filtered;
   GValue value = G_VALUE_INIT;
@@ -201,9 +201,9 @@ test_nested (void)
   guint counter = 0;
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));
 
   list_expr = gtk_object_expression_new (G_OBJECT (filtered));
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
@@ -227,13 +227,13 @@ test_nested (void)
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
   g_value_unset (&value);
 
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 0);
 
   g_clear_object (&filter);
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "salad");
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_string_filter_set_search (filter, "salad");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
@@ -242,7 +242,7 @@ test_nested (void)
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
   g_value_unset (&value);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "bar");
+  gtk_string_filter_set_search (filter, "bar");
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
@@ -279,7 +279,7 @@ test_nested_this_destroyed (void)
   GtkExpression *list_expr;
   GtkExpression *filter_expr;
   GtkExpression *expr;
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListModel *list;
   GtkFilterListModel *filtered;
   GValue value = G_VALUE_INIT;
@@ -288,9 +288,9 @@ test_nested_this_destroyed (void)
   guint counter = 0;
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));
 
   list_expr = gtk_object_expression_new (G_OBJECT (filtered));
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
@@ -307,15 +307,15 @@ test_nested_this_destroyed (void)
   g_assert_cmpint (counter, ==, 0);
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "salad");
-  gtk_filter_list_model_set_filter (filtered, filter);
+  gtk_string_filter_set_search (filter, "salad");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
   g_assert_cmpint (counter, ==, 1);
   counter = 0;
 
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_false (res);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "bar");
+  gtk_string_filter_set_search (filter, "bar");
   g_assert_cmpint (counter, ==, 0);
 
   gtk_filter_list_model_set_filter (filtered, NULL);
@@ -346,7 +346,7 @@ test_type_mismatch (void)
   GValue value = G_VALUE_INIT;
   gboolean res;
 
-  filter = gtk_any_filter_new ();
+  filter = GTK_FILTER (gtk_any_filter_new ());
 
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_constant_expression_new (GTK_TYPE_ANY_FILTER, filter), "search");
 
@@ -362,8 +362,8 @@ test_type_mismatch (void)
 static void
 test_this (void)
 {
-  GtkFilter *filter;
-  GtkFilter *filter2;
+  GtkStringFilter *filter;
+  GtkStringFilter *filter2;
   GtkExpression *expr;
   GValue value = G_VALUE_INIT;
   gboolean res;
@@ -371,10 +371,10 @@ test_this (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
+  gtk_string_filter_set_search (filter, "word");
 
   filter2 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
 
   res = gtk_expression_evaluate (expr, filter, &value);
   g_assert_true (res);
@@ -417,8 +417,8 @@ test_constant_watch_this_destroyed (void)
 static void
 test_bind (void)
 {
-  GtkFilter *target;
-  GtkFilter *source;
+  GtkStringFilter *target;
+  GtkStringFilter *source;
   GtkExpression *expr;
   GtkExpressionWatch *watch;
   GValue value = G_VALUE_INIT;
@@ -427,25 +427,25 @@ test_bind (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
 
   target = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (target), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "word");
+  gtk_string_filter_set_search (target, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "word");
 
   source = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (source), "sausage");
+  gtk_string_filter_set_search (source, "sausage");
 
   watch = gtk_expression_bind (expr, target, "search", source);
   gtk_expression_watch_ref (watch);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "sausage");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "sausage");
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (source), "salad");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "salad");
+  gtk_string_filter_set_search (source, "salad");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_true (res);
   g_assert_cmpstr (g_value_get_string (&value), ==, "salad"); 
   g_value_unset (&value);
 
   g_object_unref (source);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (target)), ==, "salad");
+  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
   res = gtk_expression_watch_evaluate (watch, &value);
   g_assert_false (res);
   g_assert_false (G_IS_VALUE (&value));
@@ -458,7 +458,7 @@ test_bind (void)
 static void
 test_bind_self (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkExpression *expr;
 
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER,
@@ -466,11 +466,11 @@ test_bind_self (void)
                                       "ignore-case");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "word");
+  gtk_string_filter_set_search (filter, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");
 
   gtk_expression_bind (expr, filter, "search", filter);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "TRUE");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "TRUE");
 
   g_object_unref (filter);
 }
@@ -480,7 +480,7 @@ test_bind_self (void)
 static void
 test_bind_child (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GtkFilterListModel *child, *target;
   GtkExpression *expr;
 
@@ -489,15 +489,15 @@ test_bind_child (void)
                                       "filter");
 
   filter = gtk_string_filter_new (NULL);
-  child = gtk_filter_list_model_new (NULL, filter);
+  child = gtk_filter_list_model_new (NULL, GTK_FILTER (filter));
   target = gtk_filter_list_model_new (G_LIST_MODEL (child), NULL);
 
   gtk_expression_bind (expr, target, "filter", child);
   g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));
 
   filter = gtk_string_filter_new (NULL);
-  gtk_filter_list_model_set_filter (child, filter);
-  g_assert_true (filter == gtk_filter_list_model_get_filter (target));
+  gtk_filter_list_model_set_filter (child, GTK_FILTER (filter));
+  g_assert_true (GTK_FILTER (filter) == gtk_filter_list_model_get_filter (target));
   g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));
   g_object_unref (filter);
 
@@ -508,9 +508,9 @@ test_bind_child (void)
 static void
 test_nested_bind (void)
 {
-  GtkFilter *filter;
-  GtkFilter *filter2;
-  GtkFilter *filter3;
+  GtkStringFilter *filter;
+  GtkStringFilter *filter2;
+  GtkStringFilter *filter3;
   GListModel *list;
   GtkFilterListModel *filtered;
   GtkExpression *expr;
@@ -519,10 +519,10 @@ test_nested_bind (void)
   GValue value = G_VALUE_INIT;
 
   filter2 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
 
   list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
-  filtered = gtk_filter_list_model_new (list, g_object_ref (filter2));
+  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter2)));
 
   filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL,
                                              gtk_object_expression_new (G_OBJECT (filtered)),
@@ -530,17 +530,17 @@ test_nested_bind (void)
   expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter_expr), "search");
 
   filter = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "word");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "word");
+  gtk_string_filter_set_search (filter, "word");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");
 
   gtk_expression_bind (gtk_expression_ref (expr), filter, "search", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter2), "sausage");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "sausage");
+  gtk_string_filter_set_search (filter2, "sausage");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "sausage");
 
   filter3 = gtk_string_filter_new (NULL);
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter3), "banana");
-  gtk_filter_list_model_set_filter (filtered, filter3);
+  gtk_string_filter_set_search (filter3, "banana");
+  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter3));
 
   /* check that the expressions evaluate correctly */
   res = gtk_expression_evaluate (filter_expr, NULL, &value);
@@ -554,7 +554,7 @@ test_nested_bind (void)
   g_value_unset (&value);
 
   /* and the bind too */
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter)), ==, "banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "banana");
 
   g_object_unref (filter);
   g_object_unref (filter2);
@@ -592,8 +592,8 @@ test_double_bind (void)
   GtkExpression *filter_expr;
   GtkExpression *params[2];
 
-  filter1 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter2 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter1 = gtk_string_filter_new (NULL);
+  filter2 = gtk_string_filter_new (NULL);
 
   filter_expr = gtk_object_expression_new (G_OBJECT (filter1));
 
@@ -607,11 +607,11 @@ test_double_bind (void)
 
   gtk_expression_bind (gtk_expression_ref (expr), filter2, "search", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter1), "Banana");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter2)), ==, "banana");
+  gtk_string_filter_set_search (filter1, "Banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "banana");
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter1), FALSE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter2)), ==, "Banana");
+  gtk_string_filter_set_ignore_case (filter1, FALSE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "Banana");
 
   gtk_expression_unref (expr);
   gtk_expression_unref (filter_expr);
@@ -633,9 +633,9 @@ test_binds (void)
   GtkExpression *filter2_expr;
   GtkExpression *params[2];
 
-  filter1 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter2 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
-  filter3 = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
+  filter1 = gtk_string_filter_new (NULL);
+  filter2 = gtk_string_filter_new (NULL);
+  filter3 = gtk_string_filter_new (NULL);
 
   filter1_expr = gtk_object_expression_new (G_OBJECT (filter1));
   filter2_expr = gtk_object_expression_new (G_OBJECT (filter2));
@@ -653,20 +653,20 @@ test_binds (void)
   gtk_expression_bind (gtk_expression_ref (expr), filter3, "search", NULL);
   gtk_expression_bind (gtk_expression_ref (expr2), filter3, "ignore-case", NULL);
 
-  gtk_string_filter_set_search (GTK_STRING_FILTER (filter1), "Banana");
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "banana");
-  g_assert_true (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_search (filter1, "Banana");
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "banana");
+  g_assert_true (gtk_string_filter_get_ignore_case (filter3));
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter2), FALSE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "Banana");
-  g_assert_false (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_ignore_case (filter2, FALSE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
+  g_assert_false (gtk_string_filter_get_ignore_case (filter3));
 
   /* invalidate the first bind */
   g_object_unref (filter1);
 
-  gtk_string_filter_set_ignore_case (GTK_STRING_FILTER (filter2), TRUE);
-  g_assert_cmpstr (gtk_string_filter_get_search (GTK_STRING_FILTER (filter3)), ==, "Banana");
-  g_assert_true (gtk_string_filter_get_ignore_case (GTK_STRING_FILTER (filter3)));
+  gtk_string_filter_set_ignore_case (filter2, TRUE);
+  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
+  g_assert_true (gtk_string_filter_get_ignore_case (filter3));
 
   gtk_expression_unref (expr);
   gtk_expression_unref (expr2);
@@ -681,7 +681,7 @@ test_binds (void)
 static void
 test_bind_object (void)
 {
-  GtkFilter *filter;
+  GtkStringFilter *filter;
   GListStore *store;
   GtkFilterListModel *model;
   GtkExpression *expr;
@@ -694,11 +694,11 @@ test_bind_object (void)
 
   gtk_expression_bind (gtk_expression_ref (expr), model, "filter", NULL);
 
-  g_assert_true (gtk_filter_list_model_get_filter (model) == filter);
+  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));
 
   g_object_unref (filter);
 
-  g_assert_true (gtk_filter_list_model_get_filter (model) == filter);
+  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));
 
   gtk_expression_unref (expr);
   g_object_unref (model);

diff --git a/testsuite/gtk/filter.c b/testsuite/gtk/filter.c
index 921ce988b1cb4b2e6b2aed775bce6544131ee568..b16c5c432170355a21780dd56ce57396f4150765 100644 (file)
--- a/testsuite/gtk/filter.c
+++ b/testsuite/gtk/filter.c
@@ -207,7 +207,7 @@ test_simple (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
+  filter = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
   model = new_model (20, filter);
   g_object_unref (filter);
   assert_model (model, "3 6 9 12 15 18");
@@ -220,9 +220,9 @@ test_any_simple (void)
   GtkFilterListModel *model;
   GtkFilter *any, *filter1, *filter2;
 
-  any = gtk_any_filter_new ();
-  filter1 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
-  filter2 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL);
+  any = GTK_FILTER (gtk_any_filter_new ());
+  filter1 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
+  filter2 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL));
 
   model = new_model (20, any);
   assert_model (model, "");
@@ -253,12 +253,12 @@ test_string_simple (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_string_filter_new (
+  filter = GTK_FILTER (gtk_string_filter_new (
                gtk_cclosure_expression_new (G_TYPE_STRING,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (get_string),
-                                            NULL, NULL));
+                                            NULL, NULL)));
 
   model = new_model (20, filter);
   assert_model (model, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20");
@@ -276,12 +276,12 @@ test_string_properties (void)
   GtkFilterListModel *model;
   GtkFilter *filter;
 
-  filter = gtk_string_filter_new (
+  filter = GTK_FILTER (gtk_string_filter_new (
                gtk_cclosure_expression_new (G_TYPE_STRING,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (get_spelled_out),
-                                            NULL, NULL));
+                                            NULL, NULL)));
 
   model = new_model (1000, filter);
   gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "thirte");
@@ -316,12 +316,12 @@ test_bool_simple (void)
   GtkExpression *expr;
   GtkFilter *filter;
 
-  filter = gtk_bool_filter_new (
+  filter = GTK_FILTER (gtk_bool_filter_new (
                gtk_cclosure_expression_new (G_TYPE_BOOLEAN,
                                             NULL,
                                             0, NULL,
                                             G_CALLBACK (divisible_by),
-                                            GUINT_TO_POINTER (3), NULL));
+                                            GUINT_TO_POINTER (3), NULL)));
   model = new_model (20, filter);
   assert_model (model, "3 6 9 12 15 18");
 
@@ -358,10 +358,10 @@ test_every_dispose (void)
 {
   GtkFilter *filter, *filter1, *filter2;
 
-  filter = gtk_every_filter_new ();
+  filter = GTK_FILTER (gtk_every_filter_new ());
 
-  filter1 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL);
-  filter2 = gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL);
+  filter1 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (3), NULL));
+  filter2 = GTK_FILTER (gtk_custom_filter_new (divisible_by, GUINT_TO_POINTER (5), NULL));
 
   g_object_ref (filter1);
   g_object_ref (filter2);

diff --git a/testsuite/gtk/filterlistmodel-exhaustive.c b/testsuite/gtk/filterlistmodel-exhaustive.c
index 317ac64c6901879c1738fca2f40951094218867c..30c01c07a6668c6e8b0dfed1218bfd0402fe4fa7 100644 (file)
--- a/testsuite/gtk/filterlistmodel-exhaustive.c
+++ b/testsuite/gtk/filterlistmodel-exhaustive.c
@@ -217,11 +217,11 @@ create_filter (gsize id)
   {
     case 0:
       /* GTK_FILTER_MATCH_ALL */
-      return gtk_string_filter_new (NULL);
+      return GTK_FILTER (gtk_string_filter_new (NULL));
 
     case 1:
       /* GTK_FILTER_MATCH_NONE */
-      filter = gtk_string_filter_new (NULL);
+      filter = GTK_FILTER (gtk_string_filter_new (NULL));
       gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "does not matter, because no expression");
       return filter;
 
@@ -229,7 +229,7 @@ create_filter (gsize id)
     case 3:
     case 4:
       /* match all As, Bs and nothing */
-      filter = gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string"));
+      filter = GTK_FILTER (gtk_string_filter_new (gtk_property_expression_new (GTK_TYPE_STRING_OBJECT, NULL, "string")));
       if (id == 2)
         gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "A");
       else if (id == 3)
@@ -302,7 +302,7 @@ test_two_filters (gconstpointer model_id)
   source = create_source_model (10, 10);
   model1 = create_filter_list_model (model_id, source, NULL);
   model2 = create_filter_list_model (model_id, G_LIST_MODEL (model1), NULL);
-  every = gtk_every_filter_new ();
+  every = GTK_FILTER (gtk_every_filter_new ());
   compare = create_filter_list_model (model_id, source, every);
   g_object_unref (every);
   g_object_unref (source);
@@ -364,7 +364,7 @@ test_model_changes (gconstpointer model_id)
   gsize i;
 
   filter = create_random_filter (TRUE);
-  multi = gtk_every_filter_new ();
+  multi = GTK_FILTER (gtk_every_filter_new ());
   if (filter)
     gtk_multi_filter_append (GTK_MULTI_FILTER (multi), filter);
 

diff --git a/testsuite/gtk/filterlistmodel.c b/testsuite/gtk/filterlistmodel.c
index c2ad5951740c3e372cfcf12696793b563d640e29..331e63981cb5e72b45baa522661a0791ccc68e9f 100644 (file)
--- a/testsuite/gtk/filterlistmodel.c
+++ b/testsuite/gtk/filterlistmodel.c
@@ -164,7 +164,7 @@ new_model (guint               size,
   GString *changes;
 
   if (filter_func)
-    filter = gtk_custom_filter_new (filter_func, data, NULL);
+    filter = GTK_FILTER (gtk_custom_filter_new (filter_func, data, NULL));
   else
     filter = NULL;
   result = gtk_filter_list_model_new (g_object_ref (G_LIST_MODEL (new_store (1, size, 1))), filter);
@@ -234,9 +234,9 @@ test_empty_set_filter (void)
 {
   GtkFilterListModel *filter;
   GtkFilter *custom;
-  
+
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (20), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (20), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6 7 8 9 10");
@@ -244,7 +244,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (7), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (7), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6");
@@ -252,7 +252,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (0), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (0), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");
@@ -260,7 +260,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (0), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (0), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6 7 8 9 10");
@@ -268,7 +268,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (3), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (3), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "4 5 6 7 8 9 10");
@@ -276,7 +276,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (20), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (20), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");
@@ -284,7 +284,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_near, GUINT_TO_POINTER (5), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_near, GUINT_TO_POINTER (5), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "3 4 5 6 7");
@@ -292,7 +292,7 @@ test_empty_set_filter (void)
   g_object_unref (filter);
 
   filter = new_model (10, NULL, NULL);
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (5), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (5), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 8 9 10");
@@ -310,37 +310,37 @@ test_change_filter (void)
   assert_model (filter, "1 2 8 9 10");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (6), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (6), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 9 10");
   assert_changes (filter, "2-1+1");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (9), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (9), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5 6");
   assert_changes (filter, "3-2+3");
 
-  custom = gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (6), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_smaller_than, GUINT_TO_POINTER (6), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 2 3 4 5");
   assert_changes (filter, "-5");
 
-  custom = gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (4), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_larger_than, GUINT_TO_POINTER (4), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "5 6 7 8 9 10");
   assert_changes (filter, "0-5+6");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (2), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (2), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "5 6 7 8 9 10");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (4), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_not_near, GUINT_TO_POINTER (4), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "1 7 8 9 10");
@@ -354,14 +354,14 @@ test_incremental (void)
 {
   GtkFilterListModel *filter;
   GtkFilter *custom;
-  
+
   /* everything is filtered */
   filter = new_model (1000, is_larger_than, GUINT_TO_POINTER (10000));
   gtk_filter_list_model_set_incremental (filter, TRUE);
   assert_model (filter, "");
   assert_changes (filter, "");
 
-  custom = gtk_custom_filter_new (is_near, GUINT_TO_POINTER (512), NULL);
+  custom = GTK_FILTER (gtk_custom_filter_new (is_near, GUINT_TO_POINTER (512), NULL));
   gtk_filter_list_model_set_filter (filter, custom);
   g_object_unref (custom);
   assert_model (filter, "");